/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package commomgame;

/**
 * Classe abastrata que possui método que valida a movimentação de cartas a depender de outros métodos auxiliares
 * implementados também nessa classe, como a verificação de uma carta é As ou se determinada subregião está vazia.
 *
 * @author Fernanda & Igo
 */
public abstract class RulesOfMovement {

    /**
     *Método responsável por validar a movimentação de uma carta de uma determinada subregião para outra.
     * @param value inteiro referente ao valor da carta a ser movida
     * @param nipe string referente ao nipe da carta a ser movida
     * @param regionOrigin região de origem da carta a ser movida
     * @param regionTarget região de destino a qual a carta será movida
     * @return Se movimento for permitido, True, se não, False
     */
    public abstract boolean verifyMovement(int value, String nipe, SubRegion regionOrigin, SubRegion regionTarget);

    /**
     * método que verifica se o topo da sub região é uma carta As.
     * @param subRegion subregião a ser analisada
     * @return Se verdadeiro, True, Se falso, False
     */
    public boolean isAs(SubRegion subRegion) {

        if (subRegion.showValueTopOfSubRegion() == 1) {
            return true;
        }

        return false;
    }

    /**
     * Método que verifica se o valor de uma carta representa um K, ou seja, se o mesmo é 13.
     * @param value inteiro que representa o valor da carta a ser analisado
     * @return Se verdadeiro, True, Se falso, False
     */
    public boolean isK(int value) {

        if (value == 13) {
            return true;
        }

        return false;

    }

    /**
     * Método que verifica a ascendência entre a carta topo da subregião e o valor de uma outra carta.
     * Ou seja, verifica se o valor passado como parâmetro é acrescido de um em relação ao valor da carta do topo da
     * subregião.
     * @param subRegion subregião a ser analisada
     * @param value inteiro que representa o valor da carta a ser comparada com a carta topo da subregião
     * @return Se ascendente, True, Se não, False
     */
    public boolean isAscendent(SubRegion subRegion, int value) {
        if (value == subRegion.showValueTopOfSubRegion() + 1) {
            return true;
        }
        return false;
    }

    /**
     * Método que verifica a descendência entre a carta topo da subregião e o valor de uma outra carta.
     * Ou seja, verifica se o valor passado como parâmetro é decrescido de um em relação ao valor da carta do topo da
     * subregião.
     * @param subRegion subregião a ser analisada
     * @param value inteiro que representa o valor da carta a ser comparada com a carta topo da subregião
     * @return Se descendente, True, Se não, False
     */
    public boolean isDescendent(SubRegion subRegion, int value) {
        if (value == subRegion.showValueTopOfSubRegion() - 1) {
            return true;
        }
        return false;
    }

    /**
     * Método que verifica se a carta topo da subregião tem o mesmo nipe de uma outra carta.
     * Ou seja, verifica se o nipe passado como parâmetro é igual ao nipe da carta topo da subregião
     * @param subRegion subregião a ser analisada
     * @param nipe string que representa o nipe da carta a ser comparada com a carta topo da subregião
     * @return Se mesmo nipe, true, se não, false
     */
    public boolean isSameNipe(SubRegion subRegion, String nipe) {
        if (subRegion.showNipeTopOfSubRegion().equals(nipe)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Método que verifica se a subregião está vazia
     * @param subRegion  subregião a ser analisada
     * @return Se estiver vazia, true, se não, false
     */
    public boolean isEmptyStack(SubRegion subRegion) {

        if (subRegion.getSize() == 0) {
            return true;
        }
        return false;
    }

    /**
     * Método que verifica a alternância de cor entra a carta do topo da subregião em relação a uma outra carta.
     * Ou seja, verifica se a cor da carta passada como parâmetro é diferente da cor da carta topo da subregião.
     * @param subRegion subregião a ser analisada
     * @param nipe string referente a carta a ser comparada com o topo da subregião
     * @return se cor alternada, true, se não, false
     */
    public boolean isAlternatedColor(SubRegion subRegion, String nipe) {
        if (subRegion.showNipeTopOfSubRegion().equals("diamond") || subRegion.showNipeTopOfSubRegion().equals("heart")) {
            if (nipe.equals("spade") || nipe.equals("club")) {
                return true;
            } else {
                return false;
            }
        } else {
            if (nipe.equals("diamond") || nipe.equals("heart")) {
                return true;
            } else {
                return false;
            }
        }
    }
}
